home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cpp_libs / nihcl-30.lha / nihcl-3.0 / lib / OIOfd.c < prev    next >
C/C++ Source or Header  |  1990-05-19  |  5KB  |  169 lines
  1. /* OIOfd.c -- Implementation of file Object I/O classes
  2.  
  3.     THIS SOFTWARE FITS THE DESCRIPTION IN THE U.S. COPYRIGHT ACT OF A
  4.     "UNITED STATES GOVERNMENT WORK".  IT WAS WRITTEN AS A PART OF THE
  5.     AUTHOR'S OFFICIAL DUTIES AS A GOVERNMENT EMPLOYEE.  THIS MEANS IT
  6.     CANNOT BE COPYRIGHTED.  THIS SOFTWARE IS FREELY AVAILABLE TO THE
  7.     PUBLIC FOR USE WITHOUT A COPYRIGHT NOTICE, AND THERE ARE NO
  8.     RESTRICTIONS ON ITS USE, NOW OR SUBSEQUENTLY.
  9.  
  10. Author:
  11.     K. E. Gorlen
  12.     Bg. 12A, Rm. 2033
  13.     Computer Systems Laboratory
  14.     Division of Computer Research and Technology
  15.     National Institutes of Health
  16.     Bethesda, Maryland 20892
  17.     Phone: (301) 496-1111
  18.     uucp: uunet!nih-csl!kgorlen
  19.     Internet: kgorlen@alw.nih.gov
  20.     May, 1989
  21.  
  22. Function:
  23.     
  24. Modification History:
  25.  
  26. $Log:    OIOfd.c,v $
  27.  * Revision 3.0  90/05/20  00:20:26  kgorlen
  28.  * Release for 1st edition.
  29.  * 
  30. */
  31.  
  32. #include <ctype.h>
  33. #include "OIOfd.h"
  34. #include "OIOTbl.h"
  35.  
  36. static char rcsid[] = "$Header: /afs/alw.nih.gov/unix/sun4_40c/usr/local/src/nihcl-3.0/share/lib/RCS/OIOfd.c,v 3.0 90/05/20 00:20:26 kgorlen Rel $";
  37.  
  38. extern const int NIHCL_RDBADSIG,NIHCL_RDBADTYP,NIHCL_RDEOF,NIHCL_RDUNKCLASS,NIHCL_RDWRONGCLASS,NIHCL_READBINERR,NIHCL_READBINUNDFL,NIHCL_STOREBINERR,NIHCL_STROV;
  39.     
  40. Object* OIOifd::readObject(const Class& expectedClass)
  41. {
  42.     char recordType =-1;            // object I/O record type
  43.     const Class* readClass = 0;        // class descriptor pointer
  44.     int objectNum;                // object reference number 
  45.     unsigned short classNum;        // class reference number
  46.  
  47. // read record type byte from file descriptor
  48.     *this >> recordType;
  49.     
  50. // parse object reference, class reference, or class name & signature
  51.     switch (recordType) {
  52.         case OIOofd::storeOnObjectRef: {    // read object reference
  53.             *this >> objectNum;
  54. #ifdef DEBUG_OBJIO
  55. cerr << "readFrom: ref to object #" << objectNum
  56.     << ", class " << (Class::readFromTbl->objectAt(objectNum))->className() << '\n';
  57. #endif
  58.             return Class::readFromTbl->objectAt(objectNum);
  59.         }
  60.         case OIOofd::storeOnClassRef: {        // read class reference
  61.             unsigned short classNum;  // class reference number
  62.             *this >> classNum;
  63. #ifdef DEBUG_OBJIO
  64. cerr << "readFrom: ref to class #" << classNum << ", class ";
  65. #endif
  66.             readClass = Class::readFromTbl->classAt(classNum);
  67. #ifdef DEBUG_OBJIO
  68. cerr << *readClass << '\n';
  69. #endif
  70.             break;
  71.         }
  72.         case OIOofd::storeOnClass: {        // read class name and class signature
  73.             unsigned long signature;    // class signature 
  74.             {
  75.                 char clsName[256];
  76.                 unsigned char namelen = 0;
  77.                 *this >> namelen;
  78.                 this->get(clsName,namelen);
  79.                 clsName[namelen] = '\0';
  80.                 *this >> signature;
  81.                 if ((readClass = Class::lookup(clsName)) == 0)
  82.                     setError(NIHCL_RDUNKCLASS, DEFAULT, clsName);
  83.                 if (!readClass->_isKindOf(expectedClass))
  84.                     setError(NIHCL_RDWRONGCLASS, DEFAULT, expectedClass.name(), clsName);
  85.                 if (readClass->signature() != signature)
  86.                     setError(NIHCL_RDBADSIG, DEFAULT, clsName, readClass->signature(), signature);
  87.             }
  88.             classNum = Class::readFromTbl->add(readClass);
  89. #ifdef DEBUG_OBJIO
  90. cerr << "readFrom: class " << *readClass << '\n';
  91. #endif
  92.             break;
  93.         }
  94.         default: setError(NIHCL_RDBADTYP,DEFAULT,recordType,fd);
  95.     }
  96.  
  97. // call class object reader to read object
  98.     return readClass->readObject(*this);
  99. }
  100.  
  101. void OIOofd::storeObject(const Object& obj)
  102. {
  103.     int objectNum;
  104.      if (Class::storeOnTbl->add(obj,objectNum)) {    // object has not been stored 
  105.         unsigned short classNum;
  106.         if (Class::storeOnTbl->addClass(obj.isA(),classNum)) {    // object of this class has not been previously stored 
  107.             char recordType = storeOnClass;
  108.             *this << recordType;
  109.             unsigned char classNameLen = strlen(obj.className());
  110.             *this << classNameLen;
  111.             put(obj.className(),classNameLen);
  112.             *this << obj.isA()->signature();
  113.         }
  114.         else {            // object of this class already stored, just output class reference
  115.             char recordType = storeOnClassRef;
  116.             *this << recordType;
  117.             *this << classNum;
  118.         }
  119.         obj.storer(*this);        // call storer for this object 
  120.     }
  121.     else {        // object already stored, just output object reference
  122.                char recordType = storeOnObjectRef; 
  123.         *this << recordType;
  124.         *this << objectNum;
  125.     }
  126. }
  127.  
  128. extern int errno;
  129. extern char* sys_errlist[];
  130.  
  131. void OIOofd::writeErr()
  132. {
  133.     setError(NIHCL_STOREBINERR,DEFAULT,sys_errlist[errno]);
  134. }
  135.  
  136. OIOifd& OIOifd::get(char* buf,unsigned nbyte)
  137. {
  138.     if (nbyte > 0) {
  139.         int retval = read(fd,buf,nbyte);
  140.         if (retval == -1) 
  141.             setError(NIHCL_READBINERR,DEFAULT,sys_errlist[errno]);
  142.         if (retval == 0) 
  143.             setError(NIHCL_RDEOF,DEFAULT);
  144.         if (retval < nbyte)
  145.             setError(NIHCL_READBINUNDFL,DEFAULT,nbyte,retval);
  146.     }
  147.     return *this;
  148. }
  149.  
  150. OIOifd& OIOifd::getCString(char* s, unsigned maxlen)
  151. {
  152.     unsigned n;
  153.     *this >> n;
  154.     if (n >= maxlen) {
  155.             get(s,maxlen);
  156.         setError(NIHCL_STROV,DEFAULT,maxlen,s,maxlen);
  157.     }
  158.     get(s,n);
  159.     s[n] = '\0';
  160.     return *this;
  161. }
  162.  
  163. OIOofd& OIOofd::putCString(const char* s)
  164. {
  165.     unsigned n = strlen(s);
  166.     *this << n;
  167.     return put(s,n);
  168. }
  169.